package com.one.group.admin.controller;

import com.one.group.admin.service.impl.QuestionServiceImpl;
import com.one.group.enums.ErrorCode;
import com.one.group.model.dto.QuestionDto;
import com.one.group.result.Result;
import com.one.group.utils.ResultUtil;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * 问题Controller
 * @author kld
 */
@RestController
@RequestMapping("/question")
@Tag(name = "问题管理")
public class QuestionController {
    
    @Autowired
    private QuestionServiceImpl questionService;
    
    /**
     * 新增问题
     */
    @PostMapping("/add")
    @Operation(summary = "新增问题")
    public Result add(@RequestBody QuestionDto addDto) {
        // 参数校验
        if (addDto.getQuestionnaireId() == null || addDto.getQuestionnaireId() <= 0) {
            return ResultUtil.error(ErrorCode.PARAMS_ERROR, "问卷ID不能为空");
        }
        if (addDto.getType() == null || (addDto.getType() != 1 && addDto.getType() != 2 && addDto.getType() != 3)) {
            return ResultUtil.error(ErrorCode.PARAMS_ERROR, "问题类型无效，支持：1-单选 2-填空 3-多选");
        }
        if (addDto.getQuestion() == null || addDto.getQuestion().trim().isEmpty()) {
            return ResultUtil.error(ErrorCode.PARAMS_ERROR, "问题内容不能为空");
        }
        if (addDto.getIsRequired() == null) {
            return ResultUtil.error(ErrorCode.PARAMS_ERROR, "请指定是否必填");
        }

        
        // 调用服务层新增问题
        boolean result = questionService.addQuestion(addDto);
        
        if (result) {
            return ResultUtil.success("新增问题成功");
        } else {
            return ResultUtil.error(ErrorCode.OPERATION_ERROR, "新增问题失败");
        }
    }
    
    /**
     * 获取问题详情
     */
    @GetMapping("/detail")
    @Operation(summary = "获取问题详情")
    public Result detail(Long questionId) {
        // 参数校验
        if (questionId == null || questionId <= 0) {
            return ResultUtil.error(ErrorCode.PARAMS_ERROR, "问题ID不能为空");
        }
        
        // 调用服务层获取问题详情
        Object result = questionService.getQuestionDetail(questionId);
        
        if (result != null) {
            return ResultUtil.success(result);
        } else {
            return ResultUtil.error(ErrorCode.OPERATION_ERROR, "问题不存在或不属于当前租户");
        }
    }
    
    /**
     * 更新问题
     */
    @PostMapping("/update")
    @Operation(summary = "更新问题")
    public Result update(@RequestParam Long questionId, @RequestBody QuestionDto addDto) {
        // 参数校验
        if (questionId == null || questionId <= 0) {
            return ResultUtil.error(ErrorCode.PARAMS_ERROR, "问题ID不能为空");
        }
        if (addDto.getType() == null || (addDto.getType() != 1 && addDto.getType() != 2 && addDto.getType() != 3)) {
            return ResultUtil.error(ErrorCode.PARAMS_ERROR, "问题类型无效，支持：1-单选 2-填空 3-多选");
        }
        if (addDto.getQuestion() == null || addDto.getQuestion().trim().isEmpty()) {
            return ResultUtil.error(ErrorCode.PARAMS_ERROR, "问题内容不能为空");
        }
        if (addDto.getIsRequired() == null) {
            return ResultUtil.error(ErrorCode.PARAMS_ERROR, "请指定是否必填");
        }

        
        // 调用服务层更新问题
        boolean result = questionService.updateQuestion(questionId, addDto);
        
        if (result) {
            return ResultUtil.success("更新问题成功");
        } else {
            return ResultUtil.error(ErrorCode.OPERATION_ERROR, "更新问题失败或问题不存在");
        }
    }
    
    /**
     * 根据问卷ID查询所有问题
     */
    @GetMapping("/list-by-questionnaire")
    @Operation(summary = "根据问卷ID查询问题列表")
    public Result getQuestionsByQuestionnaireId(@RequestParam Long questionnaireId) {
        // 参数校验
        if (questionnaireId == null || questionnaireId <= 0) {
            return ResultUtil.error(ErrorCode.PARAMS_ERROR, "问卷ID不能为空");
        }
        
        // 调用服务层查询问题列表
        return ResultUtil.success(questionService.getQuestionsByQuestionnaireId(questionnaireId));
    }
    
    /**
     * 删除问题
     */
    @PostMapping("/delete")
    @Operation(summary = "删除问题")
    public Result delete(@RequestParam Long questionId) {
        // 参数校验
        if (questionId == null || questionId <= 0) {
            return ResultUtil.error(ErrorCode.PARAMS_ERROR, "问题ID不能为空");
        }
        
        // 调用服务层删除问题
        boolean result = questionService.deleteQuestion(questionId);
        
        if (result) {
            return ResultUtil.success("删除问题成功");
        } else {
            return ResultUtil.error(ErrorCode.OPERATION_ERROR, "删除问题失败或问题不存在");
        }
    }
    
    /**
     * 删除问题选项
     */
    @DeleteMapping("/option/delete")
    @Operation(summary = "删除问题选项")
    public Result deleteOption(@RequestParam Long optionId) {
        // 参数校验
        if (optionId == null || optionId <= 0) {
            return ResultUtil.error(ErrorCode.PARAMS_ERROR, "选项ID不能为空");
        }
        
        // 调用服务层删除选项
        boolean result = questionService.deleteOption(optionId);
        
        if (result) {
            return ResultUtil.success("删除选项成功");
        } else {
            return ResultUtil.error(ErrorCode.OPERATION_ERROR, "删除选项失败或选项不存在");
        }
    }
    
    /**
     * 更新问题排序
     */
    @GetMapping("/updateQuestionSort")
    @Operation(summary = "更新问题排序")
    public Result updateQuestionSort(@RequestParam Long questionnaireId) {
        // 参数校验
        if (questionnaireId == null || questionnaireId <= 0) {
            return ResultUtil.error(ErrorCode.PARAMS_ERROR, "问卷ID不能为空");
        }
        
        // 调用服务层对问题进行排序
        boolean result = questionService.batchUpdateQuestionSort(questionnaireId);
        
        if (result) {
            return ResultUtil.success("问题排序更新成功");
        } else {
            return ResultUtil.error(ErrorCode.OPERATION_ERROR, "问题排序更新失败");
        }
    }
}











